#include <bits/stdc++.h>
using namespace std;

const int MAX = 1000005; // 最大长度
const int MOD = 1e9 + 7; // 模数
int nxt[MAX];            // KMP 前缀表
long long dp[MAX];       // 动态规划数组
string pattern;          // 输入的模式

// 快速幂函数
long long fast_power(int base, int exp) {
  long long result = 1;
  while (exp) {
    if (exp & 1)
      result = result * base % MOD;
    base = (1LL * base * base) % MOD;
    exp >>= 1;
  }
  return result;
}

// 计算模逆元
long long mod_inverse(int a) { return fast_power(a, MOD - 2); }

// 计算 a 除以 b 的结果
long long mod_divide(int a, int b) { return 1LL * a * mod_inverse(b) % MOD; }

// KMP 算法构建前缀表
void build_kmp_table(string pattern, int length) {
  nxt[1] = 0; // 从 1 开始
  for (int i = 2; i <= length; i++) {
    int j = nxt[i - 1];
    while (j > 0) {
      if (pattern[i] == pattern[j + 1]) {
        nxt[i] = j + 1;
        break;
      } else {
        j = nxt[j];
      }
    }
    if (j == 0) {
      nxt[i] = (pattern[i] == pattern[1]) ? 1 : 0;
    }
  }
}

// 状态转移函数
int transition_to(int index, int bit) { // bit = 0 或 1
  if (dp[index][bit] != -1)
    return dp[index][bit];
  if (pattern[index + 1] - '0' == bit)
    return dp[index][bit] = index + 1;
  if (index == 0)
    return dp[index][bit] = 0;
  return dp[index][bit] = transition_to(nxt[index], bit);
}

long long a[MAX], b[MAX]; // 期望值数组

int main() {
  int n;    // 模式长度
  cin >> n; // 输入模式长度
  for (int i = 0; i <= n; i++)
    dp[i][0] = dp[i][1] = -1; // 初始化状态数组为 -1

  cin >> pattern;              // 输入模式
  pattern = " " + pattern;     // 在模式前加空格以便于处理
  build_kmp_table(pattern, n); // 构建 KMP 前缀表

  a[0] = 1;
  b[0] = 0; // 初始化期望值
  a[1] = 1;
  b[1] = 2; // 初始状态

  // 动态规划计算期望值
  for (int i = 2; i <= n; i++) {
    // dp[i+1] = 2 * dp[i] - dp[j] - 2
    // j = transition_to(i-1, (pattern[i] - '0') ^ 1)
    a[i] = (2 * a[i - 1] % MOD + MOD -
            a[transition_to(i - 1, (pattern[i] - '0') ^ 1)]) %
           MOD;
    b[i] = (2 * b[i - 1] % MOD + MOD -
            b[transition_to(i - 1, (pattern[i] - '0') ^ 1)] + 2) %
           MOD;
  }

  cout << mod_divide(b[n], a[n]) << endl; // 输出期望值
}